package com.example.study1;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/*List 的多种遍历方式
增强for循环：语法简洁，适用于简单遍历，但遍历过程中不能修改集合
普通for循环：可以通过索引访问，适合需要索引位置的场景
迭代器遍历：可以在遍历时安全删除元素，避免 ConcurrentModificationException
列表迭代器：功能更强的迭代器，支持双向遍历和在遍历时添加、修改元素*/
public class ListTraversal {
    public static void main(String[] args) {
        // 创建并初始化一个字符串列表
        List<String> list = new ArrayList<>();
        list.add("Java");        // 添加编程语言 Java
        list.add("Python");      // 添加编程语言 Python
        list.add("C++");         // 添加编程语言 C++
        list.add("JavaScript");  // 添加编程语言 JavaScript

        System.out.println("=== 1. 增强for循环 ===");
        // 增强for循环 - 最简洁的遍历方式，适用于只需要读取元素的场景
        for (String language : list) {
            // language 变量依次引用列表中的每个元素
            System.out.println(language);
        }

        System.out.println("=== 2. 普通for循环 ===");
        // 普通for循环 - 可以通过索引访问元素，适合需要知道元素位置的场景
        for (int i = 0; i < list.size(); i++) {
            // 通过索引 i 访问每个元素，i 从 0 到 list.size()-1
            System.out.println("索引 " + i + ": " + list.get(i));
        }

        System.out.println("=== 3. 迭代器遍历 ===");
        // 使用迭代器遍历 - 可以在遍历时安全地删除元素
        Iterator<String> iterator = list.iterator();  // 获取列表的迭代器
        while (iterator.hasNext()) {                  // 检查是否还有下一个元素
            String element = iterator.next();         // 获取下一个元素并将迭代器移动到下一个位置
            System.out.println(element);
            // 使用迭代器的 remove 方法可以在遍历时安全删除元素
            if (element.equals("C++")) {
                iterator.remove();  // 安全删除当前元素，不会抛出 ConcurrentModificationException
            }
        }

        System.out.println("=== 4. 列表迭代器（双向遍历）===");
        // 列表迭代器 - 支持双向遍历和在遍历时添加、修改元素
        ListIterator<String> listIterator = list.listIterator();  // 获取列表迭代器

        // 正向遍历列表
        System.out.println("正向遍历:");
        while (listIterator.hasNext()) {                      // 检查是否还有下一个元素
            int index = listIterator.nextIndex();             // 获取下一个元素的索引（不移动迭代器）
            String element = listIterator.next();             // 获取下一个元素并移动迭代器
            System.out.println("索引 " + index + ": " + element);
        }

        // 反向遍历列表（需要在正向遍历完成后才能反向遍历）
        System.out.println("反向遍历:");
        while (listIterator.hasPrevious()) {                  // 检查是否还有前一个元素
            int index = listIterator.previousIndex();         // 获取前一个元素的索引（不移动迭代器）
            String element = listIterator.previous();         // 获取前一个元素并移动迭代器
            System.out.println("索引 " + index + ": " + element);
        }

        // 打印最终的列表状态
        System.out.println("最终列表: " + list);
    }
}
/*
=== 1. 增强for循环 ===
Java
Python
C++
JavaScript
=== 2. 普通for循环 ===
索引 0: Java
索引 1: Python
索引 2: C++
索引 3: JavaScript
=== 3. 迭代器遍历 ===
Java
Python
C++
JavaScript
=== 4. 列表迭代器（双向遍历）===
正向遍历:
索引 0: Java
索引 1: Python
索引 2: JavaScript
反向遍历:
索引 2: JavaScript
索引 1: Python
索引 0: Java
最终列表: [Java, Python, JavaScript]*/